import microApp from '@micro-zoe/micro-app';
import type {
  MainAppCommunication,
  SubAppCommunication,
  CommunicationConfig,
  CommunicationCallback,
  CommunicationCleanup,
} from '../types';

declare global {
  interface Window {
    microApp?: any;
    __MICRO_APP_ENVIRONMENT__?: boolean;
    __MICRO_APP_NAME__?: string;
  }
}

/**
 * 主应用通信工具创建函数
 * 
 * 功能特性：
 * - 发送数据到子应用
 * - 广播数据到所有子应用
 * - 监听来自子应用的数据
 * - 提供发送状态反馈
 * - 错误处理和清理
 */
export const createMainAppCommunication = (): MainAppCommunication => {
  return {
    /**
     * 发送数据到指定子应用
     */
    sendToSubApp: (appName: string, data: any) => {
      try {
        console.log(`发送数据到子应用 ${appName}:`, data);
        microApp.setData(appName, data);
      } catch (error) {
        console.error(`发送数据到子应用 ${appName} 失败:`, error);
        throw error;
      }
    },

    /**
     * 广播数据到所有子应用
     */
    broadcastToAllSubApps: (data: any) => {
      try {
        console.log('广播数据到所有子应用:', data);
        microApp.setGlobalData?.(data);
      } catch (error) {
        console.error('广播数据失败:', error);
        throw error;
      }
    },

    /**
     * 监听来自子应用的数据
     */
    onDataFromSubApp: (appName: string, callback: CommunicationCallback): CommunicationCleanup => {
      try {
        console.log(`开始监听来自子应用 ${appName} 的数据`);
        
        const listener = (data: any) => {
          console.log(`收到来自子应用 ${appName} 的数据:`, data);
          callback(data);
        };

        microApp.addDataListener(appName, listener);

        // 返回清理函数
        return () => {
          console.log(`停止监听来自子应用 ${appName} 的数据`);
          microApp.removeDataListener(appName, listener);
        };
      } catch (error) {
        console.error(`监听子应用 ${appName} 数据失败:`, error);
        return () => {}; // 返回空的清理函数
      }
    },
  };
};

/**
 * 子应用通信工具创建函数
 * 
 * 功能特性：
 * - 发送数据到主应用
 * - 发送数据到其他子应用
 * - 监听来自主应用的数据
 * - 监听来自其他子应用的数据
 * - 自动检测微应用环境
 */
export const createSubAppCommunication = (appName: string): SubAppCommunication => {
  // 检查是否在微应用环境中
  const isMicroAppEnvironment = typeof window !== 'undefined' && 
    (window.__MICRO_APP_ENVIRONMENT__ || window.microApp);

  if (!isMicroAppEnvironment) {
    console.warn('当前不在微应用环境中，通信功能可能无法正常工作');
  }

  return {
    /**
     * 发送数据到主应用
     */
    sendToMain: (data: any) => {
      try {
        console.log('发送数据到主应用:', data);
        
        if (window.microApp?.dispatch) {
          window.microApp.dispatch(data);
        } else {
          console.warn('microApp.dispatch 不存在，无法发送数据到主应用');
        }
      } catch (error) {
        console.error('发送数据到主应用失败:', error);
        throw error;
      }
    },

    /**
     * 发送数据到其他子应用
     */
    sendToSubApp: (targetAppName: string, data: any) => {
      try {
        console.log(`发送数据到子应用 ${targetAppName}:`, data);
        
        if (window.microApp?.setGlobalData) {
          // 通过全局数据传递，目标应用需要监听全局数据变化
          const message = {
            type: 'SUB_APP_COMMUNICATION',
            source: appName,
            target: targetAppName,
            data,
            timestamp: Date.now(),
          };
          window.microApp.setGlobalData(message);
        } else {
          console.warn('microApp.setGlobalData 不存在，无法发送数据到其他子应用');
        }
      } catch (error) {
        console.error(`发送数据到子应用 ${targetAppName} 失败:`, error);
        throw error;
      }
    },

    /**
     * 监听来自主应用的数据
     */
    onDataFromMain: (callback: CommunicationCallback): CommunicationCleanup => {
      try {
        console.log('开始监听来自主应用的数据');
        
        const listener = (data: any) => {
          console.log('收到来自主应用的数据:', data);
          callback(data);
        };

        if (window.microApp?.addDataListener) {
          window.microApp.addDataListener(listener);

          // 返回清理函数
          return () => {
            console.log('停止监听来自主应用的数据');
            if (window.microApp?.removeDataListener) {
              window.microApp.removeDataListener(listener);
            }
          };
        } else {
          console.warn('microApp.addDataListener 不存在，无法监听主应用数据');
          return () => {};
        }
      } catch (error) {
        console.error('监听主应用数据失败:', error);
        return () => {};
      }
    },

    /**
     * 监听来自其他子应用的数据
     */
    onDataFromSubApp: (targetAppName: string, callback: CommunicationCallback): CommunicationCleanup => {
      try {
        console.log(`开始监听来自子应用 ${targetAppName} 的数据`);
        
        const listener = (data: any) => {
          // 检查是否是子应用间通信消息
          if (data?.type === 'SUB_APP_COMMUNICATION' && 
              data?.target === appName && 
              data?.source === targetAppName) {
            console.log(`收到来自子应用 ${targetAppName} 的数据:`, data.data);
            callback(data.data);
          }
        };

        if (window.microApp?.addGlobalDataListener) {
          window.microApp.addGlobalDataListener(listener);

          // 返回清理函数
          return () => {
            console.log(`停止监听来自子应用 ${targetAppName} 的数据`);
            if (window.microApp?.removeGlobalDataListener) {
              window.microApp.removeGlobalDataListener(listener);
            }
          };
        } else {
          console.warn('microApp.addGlobalDataListener 不存在，无法监听其他子应用数据');
          return () => {};
        }
      } catch (error) {
        console.error(`监听子应用 ${targetAppName} 数据失败:`, error);
        return () => {};
      }
    },
  };
};

/**
 * 创建通用通信工具
 * 
 * 根据配置自动创建主应用或子应用通信工具
 */
export const createCommunication = (config: CommunicationConfig) => {
  const { appName, appType } = config;

  if (appType === 'main') {
    return createMainAppCommunication();
  } else {
    return createSubAppCommunication(appName);
  }
};